package com.tangkeyon.service.impl;

import com.google.common.base.Splitter;
import com.tangkeyon.common.Const;
import com.tangkeyon.common.ResponseCode;
import com.tangkeyon.dao.CartMapper;
import com.tangkeyon.dao.ProductMapper;
import com.tangkeyon.pojo.Cart;
import com.tangkeyon.pojo.Product;
import com.tangkeyon.service.IShoppingCartService;
import com.tangkeyon.util.BigDecimalUtil;
import com.tangkeyon.util.PropertiesUtil;
import com.tangkeyon.vo.CartProductVO;
import com.tangkeyon.vo.CartVO;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * @Author: tangkeyon@gmail.com
 * @Date: 2019/6/11 11:50
 * @Version 1.0
 */
@Service("iShoppingCartService")
public class IShoppingCartServiceImpl implements IShoppingCartService {
    @Autowired
    private CartMapper cartMapper;
    @Autowired
    private ProductMapper productMapper;

    @Override
    public ResponseCode<CartVO> addProductToCart(Integer userId,Integer productId,Integer productCount){
          if(productCount==null && productId==null){
              return  ResponseCode.createByErrorMessage("参数异常");
          }
//          用户的购物车中是否存在该商品，若不存在就添加，存在就在原先的基础上加上新的count
        Cart cart = cartMapper.selectCartByProductIdAndUserId(productId, userId);
          if(cart==null){
              Cart cartItem=new Cart();
              cartItem.setUserId(userId);
              cartItem.setProductId(productId);
              cartItem.setQuantity(productCount);
              cartItem.setChecked(Const.Cart.CHECKED);
              cartMapper.insert(cartItem);
          }else{
              cart.setQuantity(cart.getQuantity()+productCount);
              cartMapper.updateByPrimaryKeySelective(cart);
          }
           return this.list(userId);
     }

     @Override
    public ResponseCode<CartVO> deleteProduct(Integer userId,String productIds){
        List<String> productIdList = Splitter.on(",").splitToList(productIds);
        if(CollectionUtils.isEmpty(productIdList)){
            return  ResponseCode.createByErrorMessage("未选中商品");
        }
        cartMapper.deleteProductByIdProductId(userId,productIdList);
        return this.list(userId);
    }

    @Override
    public ResponseCode<CartVO> updateCount(Integer userId,Integer productId,Integer productCount){
        if(productCount==null && productId==null){
            return  ResponseCode.createByErrorMessage("修改商品数量错误");
        }
//        对购物车中的商品进行修改，前提是该商品在购物车中存在
        Cart cart = cartMapper.selectCartByProductIdAndUserId(productId, userId);
        if(cart !=null){
            cart.setQuantity(productCount);
            int result = cartMapper.updateByPrimaryKeySelective(cart);
            if(result==0)
                return ResponseCode.createByErrorMessage("修改商品数量失败");
        }else{
            return ResponseCode.createByErrorMessage("购物车中不存在该商品");
        }

        return this.list(userId);
    }

    @Override
    public ResponseCode<Integer> getCount(Integer userId){
        int resultCount = cartMapper.SelectAllCountByUserId(userId);
        return  ResponseCode.creatBySuccess(resultCount);
    }

    @Override
    public ResponseCode<CartVO> list(Integer userId){
        CartVO cartVO = this.getCartVOLimit(userId);
        return ResponseCode.creatBySuccess(cartVO);
    }

    /**
     * @Description: 商品的各种选中状态可以设计一个通用的方法来使用，通过传入不同的参数实现不同的选中状态
     * @param userId
     * @param productId
     * @param operation
     * @return
     */
    @Override
    public ResponseCode<CartVO> selectOrUnSelect(Integer userId, Integer productId, Integer operation) {
        int resultCont = cartMapper.updateSelectOrUnSelect(userId, productId, operation);
        if(resultCont==0){
            return ResponseCode.createByErrorMessage("商品选中操作错误");
        }
        return this.list(userId);
    }

    /**根据userId在cart数据表中查出对应的商品并封装到购物车对象中
     * @Description: 根据
     * @param userId
     * @return
     */
    private CartVO getCartVOLimit(Integer userId){
        CartVO cartVO=new CartVO();
        BigDecimal cartTotalPrice=new BigDecimal("0");
        CartProductVO cartProductVO=new CartProductVO();
        List<CartProductVO> cartProductVOList=new ArrayList<>();
//        查出当前用户购物车中的商品
        List<Cart> cartList = cartMapper.selectCartByUserId(userId);
//        将POJO类型的Cart对象装配为CartProductVO对象
        for(Cart cartItem:cartList){
            cartProductVO.setUserId(cartItem.getUserId());
            cartProductVO.setProductId(cartItem.getProductId());
            cartProductVO.setProductChecked(cartItem.getChecked());
            cartProductVO.setId(cartItem.getId());
//         根据ProductId查询商品的详细信息将CartProductVO对象的其他属性赋值
            Product product = productMapper.selectByPrimaryKey(cartProductVO.getProductId());
            if(product !=null){
                cartProductVO.setProductName(product.getName());
                cartProductVO.setProductMainImage(product.getMainImage());
                cartProductVO.setProductStock(product.getStock());
                cartProductVO.setProductPrice(product.getPrice());
                cartProductVO.setProductStatus(product.getStatus());
                cartProductVO.setProductSubtitle(product.getSubtitle());
            }
            if(product.getStock()>=cartItem.getQuantity()){
                cartProductVO.setProductCount(cartItem.getQuantity());
                cartProductVO.setLimitQuantity(Const.Cart.LIMIT_NUM_SUCCESS);
            }else{//购物车中商品的购买数量超过该商品的库存则将购物车中该商品的数量设置为库存数
                cartItem.setQuantity(product.getStock());
                cartProductVO.setProductCount(cartItem.getQuantity());
                cartProductVO.setLimitQuantity(Const.Cart.LIMIT_NUM_FAIL);
//                更新购物车表中该商品的数量
                cartMapper.updateByPrimaryKeySelective(cartItem);
            }
//            计算某个商品的总价
            cartProductVO.setProductTotalPrice(BigDecimalUtil.multiply(cartProductVO.getProductCount().doubleValue(),cartProductVO.getProductPrice().doubleValue()));
            cartProductVO.setProductChecked(Const.Cart.CHECKED);
           //如果购物车中的某个商品被选中,就将该商品的总价添加到购物车总价中
            if(cartItem.getChecked()==Const.Cart.CHECKED){
                cartTotalPrice=BigDecimalUtil.add(cartTotalPrice.doubleValue(),cartProductVO.getProductTotalPrice().doubleValue());
            }
//            将购物车商品添加到购物车中
               cartProductVOList.add(cartProductVO);
        }
//           对购物车对象进行初始化
              cartVO.setCartProductVOList(cartProductVOList);
              cartVO.setCartTotalPrice(cartTotalPrice);
              cartVO.setImageHost(PropertiesUtil.getProperty("ftp.server.http.prefix"));
//            若购物车中所有的商品都为全选，那么购物车就为全选状态
              cartVO.setAllChecked(this.getAllCheckedStatus(userId));

              return  cartVO;
    }

    private boolean getAllCheckedStatus(Integer userId){
        if(userId==null)
            return false;
           return cartMapper.selectCheckedByUserId(userId) ==0;
    }


}
